﻿/*
Nombre:                         CategoriaDao
Descripcion:                    Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.LINQ.CategoriaDao
Dependencias:                 
Fecha de creación:              20080929
Autor:                          VMORALES
Fecha de modifcación:         	20090401
Responsable:                  	VMORALES
Num. de modifcación:            1
*/

#region Imports

using NUnit.Framework;
using Electrocucaracha.AdminPersonal.DAO.Entidades;
using Spring.Context.Support;
using Spring.Context;
using System.IO;
using System;
using System.Configuration;
using System.Collections.Generic;
using System.Linq.Expressions;
using log4net.Config;

#endregion

namespace Electrocucaracha.AdminPersonal.DAO.Test
{
    [TestFixture(Description = "Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.LINQ.CategoriaDao")]
    public class CategoriaDao : GenericoDao<CategoriaDao, CategoriaDTO>
    {
        #region Constantes

        public const int CANTIDAD_ENTIDADES_PRUEBA = 5;

        #endregion

        #region Miembros

        public readonly static string Instancia = "CategoriaDao";
        private ICategoriaDao dao;
        private DateTime inicio;
        private DateTime inicioAplicacion;
        private int id = -1;
        private string descripcionUtilizada = "Prueba-" + DateTime.Today.ToShortDateString();
        private int categoriasCreadas;

        #endregion

        #region Propiedades

        #endregion

        #region Constructores

        #endregion

        #region Funciones

        /// <summary>
        /// Funcion que formatea la categoria para que sea mostrado en el log
        /// </summary>
        /// <param name="categoria">Instancia a ser formateada</param>
        /// <returns>Id, estatus y descripcion</returns>
        public override string Formatear(CategoriaDTO categoria)
        {
            return String.Format("id :\t{0}\t{1}\tDescripcion : {2}",
                categoria.Id,
                (categoria.Activo ? "Activo\t" : "Inactivo"),
                categoria.Descripcion);
        }//Formatear

        /// <summary>
        /// Funcion que obtiene un objeto dao que comparten todas las pruebas
        /// </summary>
        [TestFixtureSetUp]
        public void Inicializar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Inicializar()");

            inicioAplicacion = DateTime.Now;

			ImprimirDebug("Inicio del caso de prueba : " + inicioAplicacion.ToShortDateString());

            IApplicationContext ctx = new XmlApplicationContext("file://DAO.xml");
            ImprimirDebug(CategoriaDao.Instancia + ".Inicializar()");
            dao = (ICategoriaDao)ctx.GetObject(CategoriaDao.Instancia);
            Assert.IsNotNull(dao, "No se pudo obtener una instancia dao para el catalogo de categorias");

            AgregarDatos();

            ImprimirInfo("Fin Test.CategoriaDao.Inicializar()");
        }//Inicializar

        /// <summary>
        /// Funcion que agrega a la base de datos un conjunto de datos para realizar las pruebas
        /// </summary>
        public void AgregarDatos()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.AgregarDatos()");

            CategoriaDTO tmp = null;
            CategoriaDTO[] categorias = null;

            ImprimirDebug("Agregando categorias a la base de datos");
            for (int i = 0; i < CANTIDAD_ENTIDADES_PRUEBA; i++)
            {
                tmp = new CategoriaDTO() { Descripcion = descripcionUtilizada + "[" + i + "]", Activo = true };
                Assert.IsTrue(dao.Agregar(ref tmp), "No se pudo agregar la categoria numero : " + i);
            }

            //Desactivo la mitad de las categorias agregados
            categorias = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(categorias, "No se pudieron obtener las categorias de prueba agregadas");
            categoriasCreadas = categorias.Length;
            Assert.AreEqual(CANTIDAD_ENTIDADES_PRUEBA, categoriasCreadas, "No se crearon la cantidad de categorias solicitada");
            if (categorias.Length > 1)
            {
                id = categorias[0].Id;
                ImprimirDebug("Id. a ser utilizado en las pruebas : " + id);
            }

            ImprimirDebug("Desactivando algunas categorias de la base de datos");
            for (int i = 0; i < categorias.Length; i+=2)
            {
                Assert.IsTrue(dao.Desactivar(categorias[i]), "No se pudo desactivar la categoria con id : " + categorias[i]);
            }

            ImprimirInfo("Fin Test.CategoriaDao.AgregarDatos()");
        }//AgregarDatos

        /// <summary>
        /// Funcion que libera recursos y restablece los valores en la tabla
        /// </summary>
        [TestFixtureTearDown]
        public void Finalizar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Finalizar()");

            EliminarDatos();

            ImprimirDebug("Duracion total : " + (DateTime.Now - inicioAplicacion).TotalSeconds + " seg.");

            ImprimirInfo("Fin Test.CategoriaDao.Finalizar()");
        }//Finalizar

        /// <summary>
        /// Funcion que elimina de la base de datos el conjunto de datos agregados para realizar pruebas
        /// </summary>
        private void EliminarDatos()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.EliminarDatos()");

            //Desactivo la mitad de los bancos agregados
            CategoriaDTO[] categorias = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(categorias, "No obtuvo ninguna categoria con la descripcion utilizada");
            Assert.AreEqual(categorias.Length, CANTIDAD_ENTIDADES_PRUEBA, "Se obtuvieron mas categorias con la misma descripcion");
            ImprimirDebug("Eliminando categorias de la base de datos");
            Assert.AreEqual(dao.Eliminar(categorias), categorias.Length, "No se pudo eliminar todos las categorias de prueba");

            ImprimirDebug("Reseteando el identificador de la tabla");
            dao.ResetearId();

            ImprimirInfo("Fin Test.CategoriaDao.EliminarDatos()");
        }//EliminarDatos

        /// <summary>
        /// Funcion que imprime en la bitacora datos utilices acerca de la tabla de bancos
        /// </summary>
        [SetUp]
        public void ImprimirEstatusAntes()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ImprimirEstatusAntes()");

            int cant = dao.ObtenerCantidad();

            ImprimirDebug("ImprimirEstatusAntes()");
            ImprimirDebug("Cantidad de categorias existentes antes de la prueba: " + cant);
            if (cant > 0)
            {
                ImprimirDebug("Categorias existentes: ", dao.Obtener());
            }

            ImprimirDebug("-------------------------------------------------------------------------------\n");

            // TODO: Imprimir el ultimo identificador de la tabla
            inicio = DateTime.Now;

            ImprimirInfo("Fin Test.CategoriaDao.ImprimirEstatusAntes()");
        }//ImprimirEstatusAntes

        /// <summary>
        /// Funcion que elimina los datos temporales del catalogo utilizados para las pruebas
        /// </summary>
        [TearDown]
        public void ImprimirEstatusDespues()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ImprimirEstatusDespues()");

            ImprimirDebug("-------------------------------------------------------------------------------\n");

            int cant = dao.ObtenerCantidad();

            ImprimirDebug("ImprimirEstatusDespues()");
            ImprimirDebug("Cantidad de categorias existentes despues de la prueba: " + cant);
            if (cant > 0)
            {
                ImprimirDebug("Categorias existentes: ", dao.Obtener());
            }

            // TODO: Imprimir el ultimo identificador de la tabla
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");

            ImprimirInfo("Fin Test.CategoriaDao.ImprimirEstatusDespues()");
        }//ImprimirEstatusDespues

        #endregion

        #region IGenericoDao

        /// <summary>
        /// Valida que se pueda agregar categorias a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar categorias a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Agregar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Agregar()");

            const string descripcionAgregar = "Agregar";

            ImprimirDebug("Obteniendo la cantidad de categorias inicial");
            int cantidadAntes = dao.ObtenerCantidad();
            ImprimirDebug("Cantidad de categorias existentes : " + cantidadAntes);
            CategoriaDTO categoriaPrueba = new CategoriaDTO()
            {
                Descripcion = descripcionAgregar,
                Activo = true
            };

            Assert.IsNotNull(categoriaPrueba, "No se pudo inicializar los campos para el objeto a ser agregado");
            ImprimirDebug("Categoria a ser agregada : ", categoriaPrueba);
            Assert.IsTrue(dao.Agregar(ref categoriaPrueba), "Ha ocurrido algun error al intentar agregar una categoria");
            ImprimirDebug("Categoria agregada: ", categoriaPrueba);
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de categorias despues de la accion de agregar");

            //Validando los datos contra la base de datos
            ImprimirDebug("Validando los datos contra la base de datos");
            CategoriaDTO categoriaBD = dao.Obtener(categoriaPrueba.Id);
            Assert.IsNotNull(categoriaBD, "No se pudo obtener la categoria agregada en la base de datos");
            ImprimirDebug("Categoria obtenida desde la base de datos : ", categoriaBD);
            Assert.AreEqual(categoriaBD.Descripcion, descripcionAgregar, "No coinciden la descripcion de la categoria agregada");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO categoriaInvalida = new CategoriaDTO() { Id = -1 };
            ImprimirDebug("Categoria invalida a agregar : ", categoriaInvalida);
            Assert.Throws<DAOException>(() => dao.Agregar(ref categoriaInvalida));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Eliminar(categoriaPrueba), "No se pudo eliminar la categoria que fue agregada en la prueba");

            ImprimirInfo("Fin Test.CategoriaDao.Agregar()");
        }//Agregar

        /// <summary>
        /// Valida que se pueda agregar varias categorias a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar varias categorias a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void AgregarVarios()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.AgregarVarios()");

            int cantidadAntes = dao.ObtenerCantidad();
            const int cantidadCategoriasAgregar = 5;
            const string descripcionAgregar = "Agregar";

            ImprimirDebug("Cantidad de bancos a agregar: " + cantidadCategoriasAgregar);
            CategoriaDTO[] categoriasPrueba = new CategoriaDTO[cantidadCategoriasAgregar];
            for (int i = 0; i < categoriasPrueba.Length; i++)
            {
                categoriasPrueba[i] = new CategoriaDTO()
                {
                    Descripcion = descripcionAgregar + i,
                    Activo = (1 % 2 == 1)
                };
            }

            Assert.IsNotEmpty(categoriasPrueba, "No se pudo inicializar las categorias a ser agregadas");
            ImprimirDebug("Categorias a ser agregadas : " , categoriasPrueba);
            Assert.AreEqual(dao.Agregar(ref categoriasPrueba), categoriasPrueba.Length, "Ha ocurrido algun error al intentar agregar las categorias");
            ImprimirDebug("Categorias agregadas : ", categoriasPrueba);
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de categorias despues de la accion de agregar");

			//Validando los datos contra la base de datos
            ImprimirDebug("Validando los datos contra la base de datos");
            CategoriaDTO[] CategoriasBD = dao.ObtenerPorDescripcionSimilar(descripcionAgregar);
            Assert.IsNotNull(CategoriasBD, "No se obtuvieron las categorias agregadas de la base de datos");
            Assert.IsNotEmpty(CategoriasBD, "El conjunto de categorias obtenidas esta vacio");
            ImprimirDebug("Cantidad de categorias obtenidas desde la base de datos : " + CategoriasBD.Length);
			Assert.AreEqual(CategoriasBD.Length, cantidadCategoriasAgregar, "No coinciden la cantidad de categorias agregadas");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO[] categoriasInvalidas = new CategoriaDTO[categoriasPrueba.Length];
            for (int i = 0, j = -1; i < categoriasInvalidas.Length; i++, j--)
            {
                categoriasInvalidas[i] = new CategoriaDTO();
                categoriasInvalidas[i].Id = j;
            }

            ImprimirDebug("Categorias invalidas a agregar : ", categoriasInvalidas);
            Assert.Throws<DAOException>(() => dao.Agregar(ref categoriasInvalidas));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(dao.Eliminar(categoriasPrueba), categoriasPrueba.Length, "No se pudo eliminar las categorias que fueron utilizadas en la prueba");

            ImprimirInfo("Fin Test.CategoriaDao.AgregarVarios()");
        }//AgregarVarios

        /// <summary>
        /// Valida que se pueda elimar una categoria de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda elimar una categoria de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Eliminar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Eliminar()");

            int cantidadAntes = dao.ObtenerCantidad();

            //Obtengo una categoria de prueba a ser eliminada
            ImprimirDebug("Obteniendo la categoria de prueba...");
            CategoriaDTO c = dao.Obtener(id);
            Assert.IsNotNull(c, "No se pudo obtener la categoria a ser utilizada en la prueba");

            //Elimino la categoria de prueba
            ImprimirDebug("Categoria a eliminar : ", c);
            ImprimirDebug("Cantidad de categorias existentes : " + cantidadAntes);
            Assert.IsTrue(dao.Eliminar(c), "No se pudo elminar la categoria de prueba");

            //Comprabacion de datos en la base de datos
            ImprimirDebug("Comprobando datos guardados en la base de datos");
            Assert.Less(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de categorias registradas en la base de datos");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO categoriaInvalida = new CategoriaDTO() { Id = -1 };
            ImprimirDebug("Categoria invalida a eliminar : ", categoriaInvalida);
            Assert.Throws<DAOException>(() => dao.Eliminar(categoriaInvalida));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Agregar(ref c), "No se pudo restablecer los datos de prueba");
            id = c.Id;

            ImprimirInfo("Fin Test.CategoriaDao.Eliminar()");
        }//Eliminar

        /// <summary>
        /// Valida que se pueda eliminar varias categorias a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda eliminar varios Categorias a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void EliminarVarios()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.EliminarVarios()");

            //Obtengo un conjunto de categorias de prueba a ser eliminadas
            ImprimirDebug("Obteniendo las categorias de prueba...");
            CategoriaDTO[] categoriasPrueba = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(categoriasPrueba, "No se pudieron obtener las categorias para la prueba");
            ImprimirDebug("Cantidad de categorias a eliminar : " + categoriasPrueba.Length);
            Assert.AreEqual(categoriasPrueba.Length, CANTIDAD_ENTIDADES_PRUEBA, "No se obtuvo la misma cantidad de categorias para la prueba");

            ImprimirDebug("Categorias a ser eliminadas : ", categoriasPrueba);
            Assert.AreEqual(categoriasPrueba.Length, dao.Eliminar(categoriasPrueba), "No se pudieron eliminar todas las categorias de prueba");
            ImprimirDebug("Categorias eliminadas exitosamente");

            ImprimirDebug("Validando contra la base de datos");
            foreach (CategoriaDTO c in categoriasPrueba)
            {
                ImprimirDebug("Validando la inexistencia de la categoria : ", c);
                Assert.IsFalse(dao.Existe(c), "Se encontro la categoria con id : " + c.Id);
            }

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO[] categoriasInexistentes = new CategoriaDTO[categoriasPrueba.Length];
            for (int i = 0, j = -1; i < categoriasInexistentes.Length; i++, j--)
            {
                categoriasInexistentes[i] = new CategoriaDTO();
                categoriasInexistentes[i].Id = j;
            }

            ImprimirDebug("Categorias inexistentes a eliminar : ", categoriasInexistentes);
            Assert.Throws<DAOException>(() => dao.Eliminar(categoriasInexistentes));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(categoriasPrueba.Length, dao.Agregar(ref categoriasPrueba), "No se pudieron restaurar todas las categorias de prueba");
            for (int i = 0; i < categoriasPrueba.Length; i += 2)
            {
                Assert.IsTrue(dao.Desactivar(categoriasPrueba[i]), "No se pudo desactivar la categoria con id : " + categoriasPrueba[i]);
            }
            if (categoriasPrueba.Length > 1)
            {
                id = categoriasPrueba[0].Id;
            }

            ImprimirInfo("Fin Test.CategoriaDao.EliminarVarios()");
        }//EliminarVarios

        /// <summary>
        /// Valida que se pueda obtener un Categoria a partir de su identificador
        /// </summary>
        [Test(Description = "Valida que se pueda obtener un Categoria a partir de su identificador")]
        [Category("IGenericoDao")]
        public void ObtenerPorId()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ObtenerPorId()");

            ImprimirDebug("Obteniendo la categoria con el id : " + id);
            CategoriaDTO categoriaPrueba = dao.Obtener(id);

            Assert.IsNotNull(categoriaPrueba, "No se pudo obtener la categoria con el identificador : " + id);
            ImprimirDebug("Categoria obtenido : ", categoriaPrueba);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            Assert.Throws<DAOException>(() => dao.Obtener(-2));

            ImprimirInfo("Fin Test.CategoriaDao.ObtenerPorId()");
        }//ObtenerPorId

        /// <summary>
        /// Valida que se pueda obtener todos los Categorias de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener todos los Categorias de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerTodos()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ObtenerTodos()");

            CategoriaDTO[] categoriasPrueba = dao.Obtener();
            Assert.IsNotNull(categoriasPrueba, "Se obtuvo un objeto nulo");
            Assert.IsNotEmpty(categoriasPrueba, "No se pudo obtener alguna categoria de la capa de persistencia");
            ImprimirDebug("Categorias obtenidas : ", categoriasPrueba);

            ImprimirDebug("Validando cantidad de categorias obtenidas");
            Assert.AreEqual(categoriasPrueba.Length, dao.ObtenerCantidad(), "No se pudo obtener todos las categorias de la capa de persistencia");

            ImprimirInfo("Fin Test.CategoriaDao.ObtenerTodos()");
        }//ObtenerTodos

        /// <summary>
        /// Valida que se pueda actualizar un Categoria en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar una categoria en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Actualizar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Actualizar()");

            string descripcionNueva = "Actualizar";
            string descripcionOriginal;

            //Obtengo una categoria de prueba a ser actualizada
            ImprimirDebug("Obteniendo la categoria de prueba...");
            CategoriaDTO c = dao.Obtener(id);
            Assert.IsNotNull(c, "No se pudo obtener la categoria a ser utilizada en la prueba");

            //Actualizo la descripcion de la categoria agregada
            ImprimirDebug("Categoria a actualizar : ", c);
            descripcionOriginal = c.Descripcion;
            c.Descripcion = descripcionNueva;
            Assert.IsTrue(dao.Actualizar(c), "No se pudo actualizar la categoria de prueba");
            ImprimirDebug("Categoria actualizada : ", c);

            //Comparo que la nueva descripcion se encuentre en la base de datos
            ImprimirDebug("Comprobando datos guardados en la base de datos");
            c = dao.Obtener(c.Id);
            Assert.IsNotNull(c, "No se pudo obtener la categoria actualizada desde la base de datos");
            ImprimirDebug("Categoria obtenida desde la base de datos : ", c);
            Assert.AreEqual(c.Descripcion, descripcionNueva, "No fue actualizada la descripcion en la base de datos");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO categoriaInexistente = new CategoriaDTO() { Id = -1 };
            ImprimirDebug("Categoria inexistente a actualizar : ", categoriaInexistente);
            Assert.Throws<DAOException>(() => dao.Actualizar(categoriaInexistente));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            c.Descripcion = descripcionOriginal;
            Assert.IsTrue(dao.Actualizar(c), "No se pudo restablecer los datos de prueba");

            ImprimirInfo("Fin Test.CategoriaDao.Actualizar()");
        }//Actualizar

        /// <summary>
        /// Valida que se pueda actualizar un conjunto de Categorias en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar un conjunto de categorias en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ActualizarVarios()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ActualizarVarios()");

            string descripcionNueva = "Actualizar";
            IDictionary<int, string> valoresAnteriores = new Dictionary<int, string>();

            //Obtengo un conjunto de categorias de prueba a ser actualizadas
            ImprimirDebug("Obteniendo la categoria de prueba...");
            CategoriaDTO[] categoriasPrueba = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(categoriasPrueba, "No se pudieron obtener las categorias para la prueba");
            ImprimirDebug("Cantidad de categorias a actualizar : " + categoriasPrueba.Length);
            Assert.AreEqual(categoriasPrueba.Length, CANTIDAD_ENTIDADES_PRUEBA, "No se obtuvo la misma cantidad de categorias para la prueba");
            ImprimirDebug("Categorias a ser actualizadas : ", categoriasPrueba);

            ImprimirDebug("Actualizando la descripcion de las categorias de prueba");
            foreach (CategoriaDTO c in categoriasPrueba)
            {
                valoresAnteriores.Add(c.Id, c.Descripcion);
                c.Descripcion = descripcionNueva + "[" + c.Id + "]";
            }
            Assert.AreEqual(categoriasPrueba.Length, dao.Actualizar(categoriasPrueba), "No se pudieron actualizar todas las categorias de prueba");
            ImprimirDebug("Categorias actualizadas : ", categoriasPrueba);

            ImprimirDebug("Validando contra la base de datos");
            CategoriaDTO[] categoriasPruebaBD = dao.ObtenerPorDescripcionSimilar(descripcionNueva);
            Assert.IsNotNull(categoriasPruebaBD, "No se pudieron obtener las categorias actualizadas en la base de datos");
            Assert.AreEqual(categoriasPruebaBD.Length, categoriasPruebaBD.Length, "No coinciden la cantidad de categorias actualizadas en la base de datos");
            categoriasPruebaBD = null;

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO[] categoriasInexistentes = new CategoriaDTO[categoriasPrueba.Length];
            for (int i = 0, j = -1; i < categoriasInexistentes.Length; i++, j--)
            {
                categoriasInexistentes[i] = new CategoriaDTO();
                categoriasInexistentes[i].Id = j;
            }

            ImprimirDebug("Categorias inexistentes a actualizar : ", categoriasInexistentes);
            Assert.Throws<DAOException>(() => dao.Actualizar(categoriasInexistentes));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            foreach (CategoriaDTO c in categoriasPrueba)
            {
                Assert.IsTrue(valoresAnteriores.ContainsKey(c.Id), "No se guardaron todas las descripciones de los bancos");
                c.Descripcion = valoresAnteriores[c.Id];
                Assert.IsTrue(valoresAnteriores.Remove(c.Id), "No se pudo eliminar la descripcion encontrada");
            }
            Assert.AreEqual(valoresAnteriores.Count, 0, "Quedaron descripciones pendientes por restaurar");
            Assert.AreEqual(categoriasPrueba.Length, dao.Actualizar(categoriasPrueba), "No se pudieron restaurar todos los bancos de prueba");

            ImprimirInfo("Fin Test.CategoriaDao.ActualizarVarios()");
        }//ActualizarVarios

        /// <summary>
        /// Valida que se pueda validar si existe un Categoria en particular
        /// </summary>
        [Test(Description = "Valida que se pueda validar si existe un categoria en particular")]
        [Category("IGenericoDao")]
        public void Existe()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Existe()");

            ImprimirDebug("Obteniendo categoria de pruebas con id : " + id);
            CategoriaDTO categoriaPrueba = dao.Obtener(id);
            Assert.IsNotNull(categoriaPrueba, "No se pudo obtener la categoria de prueba");
            Assert.IsTrue(categoriaPrueba.Descripcion.Contains(descripcionUtilizada), "La categoria obtenida no corresponde a las usadas para realizar las pruebas");
            ImprimirDebug("Categoria obtenida : ", categoriaPrueba);

            //Validando informacion
            Assert.IsTrue(dao.Existe(categoriaPrueba), "No se pudo encontrar una categoria extraida de la capa de persistencia");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO categoriaInexistente = new CategoriaDTO() { Id = -2 };
            ImprimirDebug("Categoria inexistente a buscar : ", categoriaInexistente);
            Assert.Throws<DAOException>(() => dao.Existe(categoriaInexistente));

            ImprimirInfo("Fin Test.CategoriaDao.Existe()");
        }//Existe

        /// <summary>
        /// Valida que se pueda resetear el identificador autoincremental
        /// </summary>
        [Test(Description = "Valida que se pueda resetear el identificador autoincremental")]
        [Category("IGenericoDao")]
        public void ResetearId()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ResetearId()");

            CategoriaDTO[] categorias = dao.Obtener();
            CategoriaDTO ultimaCategoria = null;
            Assert.IsNotNull(categorias, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(categorias, "No se pudieron obtener todas las categorias de la capa de persistencia");

            ultimaCategoria = categorias[categorias.Length - 1];
            int ultimoId = ultimaCategoria.Id;
            ImprimirDebug("La ultima categoria del catalogo : ", ultimaCategoria);
            Assert.Greater(ultimoId, 0, "El ultimo identificador del catalogo de categorias no es mayor a cero");

            //Elimino bancos de prueba
            Assert.IsTrue(dao.Eliminar(ultimaCategoria), "Ha ocurrido algun error al intentar la ultima categoria");
            ImprimirDebug("Resetando el valor del identificador");
            dao.ResetearId();

            //Restablezco los datos de prueba utilizados
            Assert.IsTrue(dao.Agregar(ref ultimaCategoria), "No se pudo agregar la categoria de prueba al catalogo");
            Assert.AreEqual(ultimoId, ultimaCategoria.Id, "No se reseteo correctamente el identificador");
            ImprimirDebug("Se ha agregado la categoria : ", ultimaCategoria);

            ImprimirInfo("Fin Test.CategoriaDao.ResetearId()");
        }//ResetearId

        /// <summary>
        /// Valida que los datos del objeto sean correctos
        /// </summary>
        [Test(Description = "Valida que los datos del objeto sean correctos")]
        [Category("IGenericoDao")]
        public void Validar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Validar()");
            CategoriaDTO categoriaPrueba;

            //Validacion de objeto nulo
            ImprimirDebug("Validacion de objeto nulo");
            categoriaPrueba = null;
            Assert.Throws<DAOException>(() => dao.Validar(categoriaPrueba, Validaciones.Nulo));

            //Validacion de descripcion nula
            ImprimirDebug("Validacion de descripcion nula");
            categoriaPrueba = new CategoriaDTO() { Descripcion = null };
            Assert.Throws<DAOException>(() => dao.Validar(categoriaPrueba, Validaciones.DescripcionVacia));

            //Validacion de descripcion vacia
            ImprimirDebug("Validacion de descripcion vacia");
            categoriaPrueba.Descripcion = string.Empty;
            Assert.Throws<DAOException>(() => dao.Validar(categoriaPrueba, Validaciones.DescripcionVacia));

            //Validacion de identificador negativo
            ImprimirDebug("Validacion de identificador negativo");
            categoriaPrueba.Descripcion = "Test";
            categoriaPrueba.Id = -1;
            Assert.Throws<DAOException>(() => dao.Validar(categoriaPrueba, Validaciones.IdentificadorNegativo));

            ImprimirInfo("Fin Test.CategoriaDao.Validar()");
        }//Validar

        /// <summary>
        /// Valida cada uno de los objetos de un conjunto de datos
        /// </summary>
        [Test(Description = "Valida cada uno de los objetos de un conjunto de datos")]
        [Category("IGenericoDao")]
        public void ValidarVarios()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ValidarVarios()");

            //Validacion de objeto nulo
            ImprimirDebug("Validacion de objeto nulo");
            CategoriaDTO[] categoriaPrueba = null;
            Assert.Throws<DAOException>(() => dao.Validar(categoriaPrueba, Validaciones.Nulo));

            ImprimirInfo("Fin Test.CategoriaDao.ValidarVarios()");
        }//ValidarVarios

        /// <summary>
        /// Valida que se pueda obtener la cantidad de registros del catalogo de Categorias en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener la cantidad de registros del catalogo de categorias en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerCantidad()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ObtenerCantidad()");

            int cantidad = dao.ObtenerCantidad();
            ImprimirDebug("Cantidad obtenida mediante ObtenerCantidad() : " + cantidad);
            CategoriaDTO[] categorias = dao.Obtener();
            ImprimirDebug("Cantidad obtenida mediante Obtener() : " + categorias.Length);
            Assert.AreEqual(categorias.Length, cantidad, "La cantidad de categorias no coincide");

            ImprimirInfo("Fin Test.CategoriaDao.ObtenerCantidad()");
        }//ObtenerCantidad

        #endregion

        #region ICatalogo

        /// <summary>
        /// Valida que se puedan obtener los Categorias por medio de su descripcion
        /// </summary>
        [Test(Description = "Valida que se puedan obtener los Categorias por medio de su descripcion")]
        [Category("ICatalogo")]
        public void ObtenerPorDescripcion()
        {
            ImprimirDebug("Inicio Test.CategoriaDao.ObtenerPorDescripcion()");

            //Obtener categoria de prueba existente
            CategoriaDTO categoria = dao.Obtener(id);
            Assert.IsNotNull(categoria, "No se pudo obtener una categoria de prueba");
            ImprimirDebug("Categoria de pruebas obtenido : ", categoria);

            ImprimirDebug("Descripcion a buscar : " + categoria.Descripcion);
            CategoriaDTO[] categorias = dao.ObtenerPorDescripcion(categoria.Descripcion);
            Assert.IsNotNull(categorias, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(categorias, "No se pudo obtener un conjunto de categorias que compartan la misma descripcion");
            ImprimirDebug("Categorias obtenidas : ", categoria);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            Assert.AreEqual(dao.Eliminar(categorias), categorias.Length, "No se pudieron eliminar las categorias de prueba");
            Assert.IsNull(dao.ObtenerPorDescripcion(categoria.Descripcion), "Se obtuvo una descripcion eliminada de la base de datos");

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(dao.Agregar(ref categorias), categorias.Length, "No se pudo agregar el conjunto de categorias eliminadas");
            if (categorias.Length > 0)
            {
                id = categorias[0].Id;
                ImprimirDebug("Nuevo id de pruebas : " + id);
            }

            ImprimirDebug("Fin Test.BancoDao.ObtenerPorDescripcion()");
        }//ObtenerPorDescripcion

        /// <summary>
        /// Valida que se puedan obtener un conjunto de Categorias que comparten una descripcion similar
        /// </summary>
        [Test(Description = "Valida que se puedan obtener un conjunto de categorias que comparten una descripcion similar")]
        [Category("ICatalogo")]
        public void ObtenerTodosPorDescripcionSimilar()
        {
            ImprimirDebug("Inicio Test.CategoriaDao.ObtenerTodosPorDescripcionSimilar()");

            CategoriaDTO[] categorias = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(categorias, "Se obtuvo un objeto nulo");
            Assert.IsNotEmpty(categorias, "No se pudo obtener un conjunto de categorias que compartan la misma descripcion");
            ImprimirDebug("Categorias obtenidas : ", categorias);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            Assert.AreEqual(categorias.Length, dao.Eliminar(categorias), "No se pudo eliminar todas las categorias de prueba");
            Assert.IsNull(dao.ObtenerPorDescripcionSimilar(descripcionUtilizada), "Existen categorias con la descripcion utilizada : " + descripcionUtilizada);

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(categorias.Length, dao.Agregar(ref categorias), "No se pudieron agregar las categorias eliminadas");
            if (categorias.Length > 1)
            {
                id = categorias[0].Id;
            }

            ImprimirDebug("Fin Test.CategoriaDao.ObtenerTodosPorDescripcionSimilar()");
        }//ObtenerTodosPorDescripcionSimilar

         #endregion

        #region IActivo

        /// <summary>
        /// Valida que se puedan obtener todos los Categorias activos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todas las categorias activas de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerActivos()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ObtenerActivos()");

            CategoriaDTO[] categorias = dao.ObtenerActivos();
            ImprimirDebug("Categorias obtenidas : ", categorias);
            Assert.IsNotNull(categorias, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(categorias, "No existen categorias activas o no se pudo obtener un conjunto de categorias activas");

            //Validacion de estatus
            ImprimirDebug("Validacion de estatus");
            foreach (CategoriaDTO c in categorias)
            {
                Assert.IsTrue(c.Activo, "El estatus de la categoria es inactiva");
            }

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            IList<CategoriaDTO> categoriasPrueba = new List<CategoriaDTO>();
            foreach (CategoriaDTO c in categorias)
            {
                if (dao.Desactivar(c))
                {
                    ImprimirDebug("Categoria desactivada : ", c);
                    categoriasPrueba.Add(c);
                }
            }
            categorias = dao.ObtenerActivos();
            Assert.IsNull(categorias, "El objeto obtenido no es nulo");

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            foreach (CategoriaDTO c in categoriasPrueba)
            {
                Assert.IsTrue(dao.Activar(c), "No pudo ser activada la categoria con id : " + c.Id);
            }

            ImprimirInfo("Fin Test.CategoriaDao.ObtenerActivos()");
        }//ObtenerActivos

        /// <summary>
        /// Valida que se puedan obtener todas las categorias inactivos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todos los categorias inactivas de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerInactivos()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.ObtenerInactivos()");

            CategoriaDTO[] categorias = dao.ObtenerInactivos();
            Assert.IsNotNull(categorias, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(categorias, "No existen categorias inactivas o no se pudo obtener un conjunto de categorias inactivas");
            ImprimirDebug("Cateogorias obtenidas : ", categorias);

            //Validacion de estatus
            ImprimirDebug("Validacion de estatus");
            foreach (CategoriaDTO c in categorias)
            {
                Assert.IsFalse(c.Activo, "El estatus de la categoria es activa");
            }

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            IList<CategoriaDTO> categoriasPrueba = new List<CategoriaDTO>();
            foreach (CategoriaDTO c in categorias)
            {
                if (dao.Activar(c))
                {
                    ImprimirDebug("Categoria activa : ", c);
                    categoriasPrueba.Add(c);
                }
            }
            categorias = dao.ObtenerInactivos();
            Assert.IsNull(categorias, "El objeto obtenido no es nulo");

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            foreach (CategoriaDTO c in categoriasPrueba)
            {
                Assert.IsTrue(dao.Desactivar(c), "No pudo ser desactivada la categoria con id : " + c.Id);
            }

            ImprimirInfo("Fin Test.CategoriaDao.ObtenerInactivos()");
        }//ObtenerInactivos

        /// <summary>
        /// Valida que se pueda activar una categoria en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda activar una categoria en la capa de persistencia")]
        [Category("IActivo")]
        public void Activar()
        {
            ImprimirInfo("Inicio Test.CategoriaDao.Activar()");

            //Obtengo las categorias inactivas de pruebas
            CategoriaDTO[] categoriasInactivas = dao.ObtenerInactivos();
            Assert.IsNotNull(categoriasInactivas, "No se pudieron obtener las categorias inactivas registradas en el sistema");
            CategoriaDTO categoriaPrueba = null;
            ImprimirDebug("Obteniendo la categoria de prueba...");
            foreach (CategoriaDTO c in categoriasInactivas)
            {
                if (c.Descripcion.Contains(descripcionUtilizada))
                {
                    categoriaPrueba = c;
                    break;
                }
            }
            Assert.IsNotNull(categoriaPrueba, "No se pudo obtener una categoria inactiva para realizar pruebas");

            //Activo la categoria
            ImprimirDebug("Categoria a ser activada : ", categoriaPrueba);
            Assert.IsTrue(dao.Activar(categoriaPrueba), "No se puedo activar la categoria de prueba");
            ImprimirDebug("Categoria activada : ", categoriaPrueba);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO categoriaInexistente = new CategoriaDTO() { Id = -1, Activo = false };
            ImprimirDebug("Categoria inexistente a activar", categoriaInexistente);
            Assert.Throws<DAOException>(() => dao.Activar(categoriaInexistente));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Desactivar(categoriaPrueba), "No se pudo restablecer el estado de la categoria de prueba");

            ImprimirInfo("Fin Test.CategoriaDao.Activar()");
        }//Activar

        /// <summary>
        /// Valida que se pueda desactivar un Categoria en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda desactivar un Categoria en la capa de persistencia")]
        [Category("IActivo")]
        public void Desactivar()
        {
            ImprimirInfo("Inicio Test.Categoria.Desactivar()");

            //Obtengo los bancos activos de pruebas
            CategoriaDTO[] categoriasActivas = dao.ObtenerActivos();
            Assert.IsNotNull(categoriasActivas, "No se pudieron obtener las categorias activas registradas en el sistema");
            CategoriaDTO categoriaPrueba = null;
            ImprimirDebug("Obteniendo la categoria de prueba...");
            foreach (CategoriaDTO c in categoriasActivas)
            {
                if (c.Descripcion.Contains(descripcionUtilizada))
                {
                    categoriaPrueba = c;
                    break;
                }
            }
            Assert.IsNotNull(categoriaPrueba, "No se pudo obtener una categoria activa para realizar pruebas");

            //Desactivo la categoria
            ImprimirDebug("Categoria a ser desactivada : ", categoriaPrueba);
            Assert.IsTrue(dao.Desactivar(categoriaPrueba), "No se puedo desactivar la categoria de prueba");
            ImprimirDebug("Categoria desactivada : ", categoriaPrueba);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            CategoriaDTO categoriaInexistente = new CategoriaDTO () { Id = -1, Activo = true };
            ImprimirDebug("Categoria inexistente a desactivar", categoriaInexistente);
            Assert.Throws<DAOException>(() => dao.Desactivar(categoriaInexistente));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Activar(categoriaPrueba), "No se pudo restablecer el estado de la categoria de prueba");

            ImprimirInfo("Fin Test.Categoria.Desactivar()");
        }//Desactivar

        #endregion

    }//CategoriaDao
}//Electrocucaracha.AdminPersonal.DAO.Test